package cn.mandifal.manager.service.impl;

import cn.mandifal.manager.service.GoodsTemplateService;
import cn.mandifal.mapper.DpSpecificationOptMapper;
import cn.mandifal.mapper.DpTypeTempMapper;
import cn.mandifal.pojo.DpSpecificationOpt;
import cn.mandifal.pojo.DpSpecificationOptExample;
import cn.mandifal.pojo.DpTypeTemp;
import cn.mandifal.pojo.DpTypeTempExample;
import com.alibaba.dubbo.config.annotation.Service;
import com.alibaba.fastjson.JSON;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import entity.PageResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
 * 商品模板服务层
 * @author shun
 */
@Service
@Transactional
public class GoodsTemplateServiceImpl implements GoodsTemplateService {
    @Autowired
    private DpTypeTempMapper dpTypeTempMapper;
    @Autowired
    private DpSpecificationOptMapper dpSpecificationOptMapper;
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 查询所有
     * @return
     */
    @Override
    public List<DpTypeTemp> findAll() {
        return dpTypeTempMapper.selectByExample(null);
    }

    /**
     * 模糊查询
     * @param dpTypeTemp
     * @param pageNum 当前页 码
     * @param pageSize 每页记录数
     * @return
     */
    @Override
    public PageResult search(DpTypeTemp dpTypeTemp, int pageNum, int pageSize) {
        PageHelper.startPage(pageNum,pageSize);
        DpTypeTempExample dpTypeTempExample=new DpTypeTempExample();
        DpTypeTempExample.Criteria criteria = dpTypeTempExample.createCriteria();
        //判断是否为空
        if (dpTypeTemp != null){
            //若名字不空，加入条件
            if (dpTypeTemp.getName()!=null && dpTypeTemp.getName().length()>0){
                criteria.andNameLike("%"+dpTypeTemp.getName()+"%");
            }
            //若规格 id 不空加入条件
            if (dpTypeTemp.getSpecIds()!=null && dpTypeTemp.getSpecIds().length()>0){
                criteria.andSpecIdsLike("%"+dpTypeTemp.getSpecIds()+"%");
            }
            //若品牌 id 不空加入条件
            if (dpTypeTemp.getBrandIds() !=null && dpTypeTemp.getBrandIds().length()>0){
                criteria.andBrandIdsLike("%"+dpTypeTemp.getBrandIds()+"%");
            }
            //若扩展属性不空加入条件
            if (dpTypeTemp.getCustomAttributeItems() !=null && dpTypeTemp.getCustomAttributeItems().length()>0){
                criteria.andCustomAttributeItemsLike("%"+dpTypeTemp.getCustomAttributeItems()+"%");
            }
        }
        //若 if 语句都不执行，查询所有
        Page<DpTypeTemp> page= (Page<DpTypeTemp>) dpTypeTempMapper.selectByExample(dpTypeTempExample);
        //保存品牌和规格到缓存中
        saveToRedis();
        return new PageResult(page.getTotal(),page.getResult());
    }

    /**
     * 保存品牌和规格到缓存中
     */
    private void  saveToRedis(){
        //缓存品牌和规格
        List<DpTypeTemp> dpTypeTempList = findAll();
        for (DpTypeTemp dpTypeTemp:dpTypeTempList) {
            //缓存品牌
            //通过 json 工具转换brandid 为 map 集合类型
            List<Map> brandList = JSON.parseArray(dpTypeTemp.getBrandIds(), Map.class);
            redisTemplate.boundHashOps("brandList").put(dpTypeTemp.getId(),brandList);
            //缓存规格
            List<Map> specList = findSpecIdAndOption(dpTypeTemp.getId());
            redisTemplate.boundHashOps("specList").put(dpTypeTemp.getId(),specList);
        }
    }

    /**
     * 查询模板表，找到 spec_id,然后通过 id 查询规格选项表，得到规格选项
     * @param id
     * @return 返回{"id":27,"text":"网络"，options:[id:xxx,optionName:xxx]}形式的数据
     */
    private List<Map> findSpecIdAndOption(Long id) {
        //根据 id 得到模板对象
        DpTypeTemp dpTypeTemp = dpTypeTempMapper.selectByPrimaryKey(id);
        //用 fastJSON 转换得到的 string为 array 类型，指定转换后的 list 中数据类型
        List<Map> list = JSON.parseArray(dpTypeTemp.getSpecIds(), Map.class);
        //遍历得到的 spec_id
        for (Map map: list) {
            DpSpecificationOptExample dpSpecificationOptExample=new DpSpecificationOptExample();
            DpSpecificationOptExample.Criteria criteria = dpSpecificationOptExample.createCriteria();
            //根据 id 得到 map 中的值，转换成 Long 类型
            criteria.andSpecIdEqualTo(new Long((Integer)map.get("id")));
            //根据 spec_id 查询规格选项
            List<DpSpecificationOpt> dpSpecificationOpts = dpSpecificationOptMapper.selectByExample(dpSpecificationOptExample);
            map.put("options",dpSpecificationOpts);
        }
        return list;
    }
    /**
     * 添加模板
     * @param dpTypeTemp 模板实体
     */
    @Override
    public void add(DpTypeTemp dpTypeTemp) {
        dpTypeTemp.setCreateTime(new Date());
        dpTypeTempMapper.insert(dpTypeTemp);
    }

    /**
     * 详情
     * @param id
     * @return
     */
    @Override
    public DpTypeTemp findOne(Long id) {
        return dpTypeTempMapper.selectByPrimaryKey(id);
    }

    /**
     * 更新模板
     * @param dpTypeTemp 模板实体
     */
    @Override
    public void update(DpTypeTemp dpTypeTemp) {
        dpTypeTemp.setUpdateTime(new Date());
        dpTypeTempMapper.updateByPrimaryKey(dpTypeTemp);
    }

    /**
     * 删除规格
     * @param ids
     */
    @Override
    public void delete(Long[] ids) {
        for (Long id:ids) {
            dpTypeTempMapper.deleteByPrimaryKey(id);
        }
    }
}
